

On a Sunday evening in the middle of Tompkins Square Park in New York City’s East Village, hundreds of people gather in front of a giant papier-mâché face of a woman wearing a crown. She’s the backdrop of a play, her body made up of curtains that look like a dress but serve a dual purpose, allowing actors to scurry on and offstage.
I’m here to watch a performance called “Luddite Recreations,” which is a history of the Luddite movement—a group of artisans and textile workers who resisted the adoption of machines during the early years of the Industrial Revolution in England and whose resistance to being displaced from their work was met with violence by the British monarchy.
It’s one of the opening events of the Summer of Ludd, a weeklong series of talks and activities like how to flirt and date offline, mending, and learning to fight against data centers, all focused on getting people off their phones and into community.
Everything is so evidently handcrafted, giving it the energy of a high school production (complimentary). A small orchestra, manned by people dressed in Pride regalia, sits off to one side. Behind them, a table holds 10 different zines covering everything from how to get off Spotify to the role of surveillance technology in schools to “Why GenAI Sucks.”
The events will continue through July 5, with most major parts concentrated in Tompkins Square Park. (There will be a beach day cookout on July 4 as well as events in nearby locations in the East Village.)
At the beginning of the play, the actor playing Lord Byron, the famous British poet who supported the Luddite movement, tells the crowd of about 300 the rules for the week: Be present, and absolutely no phones, recording, or photos allowed.
None of the week’s events, including the play, are advertised online. Posters around the neighborhood advertise the Summer of Ludd, declaring “only in real life!” and booklets with the week’s schedule of events have been placed in community spaces around the area.
I found out about the event in a serendipitously offline way. Earlier in June, I was with a friend in the East Village, and we got caught in a summer downpour. As I was waiting it out in the Museum of Reclaimed Urban Space, a small venue that documents the neighborhood’s history of activism, I found the booklet outlining the Summer of Ludd’s events among several other zines, posters, and pamphlets. So here I am, phone tucked away, notebook out, playbill in hand.
The new Luddite movement has become heavily associated with Gen Z, the first generation to grow up entirely with digital technology. Despite this fact, or perhaps because of it, some young people are becoming increasingly critical of tech’s omnipresence in society. A 2025 Pew Research study found that in 2024, 48 percent of teen respondents said social media has negative effects on people their age—up from 32 percent in 2022.
In addition to young people, there are Pride-goers, families, and some older East Village veterans in attendance, one of whom explains to the young woman next to her the significance of “Bella Ciao,” which the orchestra has just played, an Italian resistance song created in response to fascism under Benito Mussolini.
The whole affair has an earnestness to it that the internet frequently loves to punish. It is, in fact, fun.
The Summer of Ludd was preempted with a press conference conducted by the organizers’ spokesperson, Gowanus the media puppet (yes, I am serious), a blue cloth being with soda-cap eyes, manned by a masked puppeteer. Gowanus was conceived of as a way for the movement to speak to the public and the media without compromising the identities of the event’s organizers, who wish to remain anonymous. According to Gowanus, New York’s Luddite Renaissance is a “loose group of organizers that have no formal affiliation as of now but have been coalescing around noticing similar problems of alienation and overreliance on Big Tech.”
The group says it began planning the summer’s events in January, trying to include off-tech alternatives for everything from movies (they’ve partnered with the Museum of Interesting Things to show 16-mm films) to long-distance chatting (there’s a hands-on shortwave radio and walkie-talkie workshop).
“We believe that the event is the medium to enact social change, where people can meet up in physical space. When we are trying to organize online, we have Mark Zuckerberg’s eyeballs and Silicon Valley’s fingers in the sacred human interactions of our lives,” Gowanus says. “We are striving to create an event that defies consumption.”
In many ways, the Summer of Ludd is political—teaching people how to get off Big Tech products, overlapping with the Luddite conference at the New School, a New York City–based university, where speakers are discussing the role of AI in the “kill chain,” a military concept describing all the steps taken before an attack. On Tuesday evening, Dan Fox, who works for a dumbphone company and hosts phone-free meetups at his Brooklyn home for other people interested in getting offline, announces his “platformless” run for president as part of the festival. But it is the desire to “defy consumption” on a personal level that animates several of the people who speak to WIRED.
“I really like that [the event] is critical of the role of technology in our lives,” says staoue, an attendee who asks to be identified by their chosen name. They started out as a computer science student at Rutgers but “accidentally ended up in humanities classes” that made them start to take an interest in the intersection of technology, politics, and art. They found the School of Radical Attention, a nonprofit focused on helping people resist “the fracking of human attention” by tech products. “Society is getting faster, and it means that we are pressured to get faster, and we’re scrolling to cope when what we really might want is to learn a new language or new hobby,” says staoue.
Andrew Maynard, a professor of advanced technology transitions at Arizona State University, says the Luddite movement was initially about labor rather than being specifically “anti-tech.” But he sees the modern use of the term as a positive way to describe someone who is “pushing back against the prevalence of tech and how it pulls away from their autonomy on multiple fronts.”
staoue says pulling back on their engagement with social media led them to be more active out in the world, particularly going to more protests against the Trump administration’s immigration policies. “There’s a tension, because I want to stay online to talk about these things, so I’m always thinking about how you hold that contradiction,” they say.
At an event called “Google in Real Life,” people can ask questions of their fellow attendees about their personal expertise. Mara McGuire, a 20-year-old student currently taking a break from school, read tarot cards for anyone interested. McGuire says she came across the group as it rehearsed the play in the park and asked how she could get involved.
“The main thing that interested me was the emphasis on human connection and finding ways to really gain other perspectives from getting out in the world,” she says. The online world, McGuire adds, is overwhelmed with information. “I wanted to be able to learn from other people.”
After an hours-long jam session, a discussion takes on a more practical flavor: how to find events without using social media.
Damian Thomas, a web developer who runs Unplatform, “the definitive guide for escaping social media and joining the indie web,” says his experience working with technology has directly inspired his involvement in the Summer of Ludd. “Most Luddites were technicians in some way, but they had to rent the infrastructure, the big machines. With things like Claude Code and SaaS, that’s what we are seeing now,” he says. Thomas says that he realizes most people can’t exactly quit social media or other tech products wholesale, but that “it’s about building infrastructure” that doesn’t push people to social media and allows them to change their personal habits.
An attendee and former Big Tech employee, who asks not to be named for fear of retaliation, says his experience working for both startups and one of the world’s biggest tech firms made him sympathetic to the Luddite movement, and concerned about the way companies are using new technology. “I quit my last job because our leadership was encouraging non-technical people to write code with AI-assisted tools and pushing them to production,” he says. “As a security engineer, that is just so concerning.”
Having worked in tech, the attendee says he knows exactly how hard it is to encourage people to change. “If you leave Facebook but all your friends are still on Facebook, you’ve just cut yourself off from your friend circle,” he says. Having alternatives is important, but the gravitational pull of big platforms or pressure from employers is likely to stymie real progress away from these tools.
This hostility toward the outsized role of technology in every part of life is part of a larger trend. More people are quitting dating apps, opting to meet people at in-person gatherings like run clubs. Commencement speakers who extol the virtues of AI have found themselves booed by college graduates. Analog technologies like cyberdecks are growing in popularity.
But, despite the high hopes at the Summer of Ludd, Maynard says that he doubts it will move the needle in a substantial way. “Even when people agree that they think these technologies are harmful, it rarely impacts the way they live their lives. They’re still using their phones, social media, AI,” he says. “But the questions a movement like this raises are critically important.”
That is what Thomas believes is the case. Even if not everyone can join the festivities or even get off social media entirely, “we are where public opinion is.”
This story originally appeared at wired.com.
The Explorer team was investigating a crash that was occuring at a relatively high rate and found that it took the form of a thread executing from an unloaded third-party DLL.
0:173> k RetAddr Call Site 00000000`557c5820 <Unloaded_LibUtils_CloudNs_3.dll>+0x265fe 00000000`00000008 <Unloaded_LibUtils_CloudNs_3.dll>+0x2b5820 00000000`0000000e 0x8 00000000`00000008 0xe 00000000`557c8c18 0x8 ffffffff`fffffffe <Unloaded_LibUtils_CloudNs_3.dll>+0x2b8c18 00000000`00000000 0xffffffff`fffffffe
There isn’t much on the stack at all.
0:173> dps @rsp 00000000`1248f920 00000000`557c5820 <Unloaded_LibUtils_CloudNs_3.dll>+0x2b5820 00000000`1248f928 00000000`00000008 00000000`1248f930 00000000`0000000e 00000000`1248f938 00000000`00000008 00000000`1248f940 00000000`557c8c18 <Unloaded_LibUtils_CloudNs_3.dll>+0x2b8c18 00000000`1248f948 ffffffff`fffffffe 00000000`1248f950 00000000`00000000 00000000`1248f958 00000000`00000000 00000000`1248f960 00000000`00000000 00000000`1248f968 00000000`00000000 00000000`1248f970 00000000`00000000 00000000`1248f978 00000000`00000000 00000000`1248f980 00000000`00000000 00000000`1248f988 00007ff9`a2117344 kernel32!BaseThreadInitThunk+0x14 00000000`1248f990 00000000`00000000 00000000`1248f998 00000000`00000000
This is just a worker thread the operates entirely inside LibDB.CloudNs.3.dll. It doesn’t have a very deep stack, so I suspect that it’s idle and is waiting for work to do.
For these types of investigations, there usually isn’t much to see directly in the crashing thread. That thread is the victim. You have to do additional research to figure out who unloaded the DLL prematurely.
Some snooping around found another stack that involves this unloaded DLL:
0:159> k RetAddr Call Site 00007ff9`9fdbbea0 ntdll!ZwWaitForMultipleObjects+0x14 00007ff9`9fdbbd9e KERNELBASE!WaitForMultipleObjectsEx+0xf0 00000000`554d65fe KERNELBASE!WaitForMultipleObjects+0xe 00000000`55765820 <Unloaded_LibDB_CloudNs_3.dll>+0x965fe 00000000`00000003 <Unloaded_LibUtils_JsonNs_3.dll>+0x255820 00000000`00000004 0x3 00000000`00000008 0x4 00000000`55768c18 0x8 ffffffff`fffffffe <Unloaded_LibUtils_CloudNs_3.dll>+0x258c18 00000000`00000000 0xffffffff`fffffffe
The most recently unloaded DLLs are
00007ff9`6d7c0000 00007ff9`6d80a000 FabrikamContextMenu.dll 00007ff9`115e0000 00007ff9`1172f000 LitWareSync.dll 00007ff9`643d0000 00007ff9`64681000 CcNamespace.dll 00000000`55440000 00000000`5550b000 LibDB_CloudNs_3.dll 00000000`55860000 00000000`55998000 LibNet_CloudNs_3.dll 00000000`557f0000 00000000`5585b000 LibJson_CloudNs_3.dll 00000000`55510000 00000000`557e7000 LibUtils_CloudNs_3.dll 00000000`561a0000 00000000`56238000 MSVCP100.dll 00000000`56240000 00000000`56312000 MSVCR100.dll 00007ff9`85130000 00007ff9`85167000 EhStorShell.dll 00007ff9`3cac0000 00007ff9`3cb61000 wpdshext.dll 00007ff9`78a00000 00007ff9`78a26000 EhStorAPI.dll 00007ff9`686f0000 00007ff9`68754000 PlayToDevice.dll 00007ff9`67110000 00007ff9`6718d000 provsvc.dll
So the LibDB.CloudNs.3.dll that got unloaded is just part of an entire ecosystem of Lib*.CloudNs.3.dll dynamic libraries that all got unloaded together.
The ringleader of this operation appears to be CcNamespace.dll, which looks like the Contoso namespace extension that adds a “Contoso” node under My Computer This PC that gives you a view into all your Contoso things stored in the Contoso cloud service. All the other DLLs are helpers that the main CcNamespace.dll uses to accomplish its tasks.
The main CcNamespace.dll was loaded by Explorer as a shell extension, and its DllCanUnloadNow function was returning S_OK when there were no active references to objects in CcNamespace.dll. Unfortunately, when it said “Sure, it’s safe to unload me”, that linchpin DLL unloaded all its minions, unaware that one of the minions (the utility library) had spun up some worker threads.
You might think that the fix is to update the utility library’s DllCanUnloadNow to return S_FALSE if there are still busy background threads.¹ But that doesn’t work because the utility library is probably not a COM DLL in the first place. It’s just a traditional DLL that CcNamespace.dll uses, and it is CcNamespace.dll that is the COM DLL.
The DllCanUnloadNow in CcNamespace.dll could warn LibUtils.CloudNs.3.dll that it should start winding down, but you’re basically in a tricky spot because the DLL_PROCESS_ATTACH cannot wait for the worker thread to exit.
I think the way to go is for the worker thread to increment the DLL reference count when it starts its worker thread, and to use FreeLibraryAndExitThread to exit the worker thread. Alternatively, it could make its worker thread a threadpool thread and use FreeLibraryWhenCallbackReturns to request that the system decrement the DLL reference count when it finishes.
This is probably something the utility library should have done anyway. I suspect that the worker thread is not something that clients of the utility library are even aware of. It is just an implementation detail of the utility library, created without the knowledge of the main DLL.
Fortunately, the application compatibility team has a copy of Contoso Cloud in their library, so even though we couldn’t reproduce the crash, we were still able to confirm that CcNamespace.dll is indeed the shell extension DLL whose unloading triggers the unloading of all the dependent DLLs.
We were about to contact Contoso with our conclusions and suggestions for improvement, but we discovered that it would be pointless because Contoso discontinued that namespace extension years ago. They replaced it with a different way of integrating their cloud content into Windows; the only people using the namespace extension are those who still using an old version, either because they don’t want to pay for the upgrade, or because they are actively avoiding the upgrade because they like the old way.
Those customers are using a product that has gone out of support. Contoso doesn’t care about those old customers any more. Windows will have to fix it without Contoso’s help.
The Explorer team added an application compatibility flag for the Contoso Cloud namespace extension to say “When you load this shell extension, do a GetModuleHandleEx with the GET_MODULE_HANDLE_EX_FLAG_PIN flag so the DLL never unloads.” That way, even if the DLL says “Sure, go ahead and unload me, it’s totally safe, trust me,” and COM does a FreeLibrary, the DLL doesn’t actually unload.
¹ Even if you manage to get return DllCanUnloadNow to return S_FALSE, it doesn’t help if COM is being uninitialized. In that case, CoUninitalize will ask a DLL if it is okay to unload now, but the answer is a foregone conclusion: If COM is shutting down, COM is going to unload all the DLLs that it loaded. It asks you if you are okay with it, not because it cares what your answer is, but to give you a chance to do cleanup outside of DllMain.
The post The case of the thread executing from an unloaded third-party DLL appeared first on The Old New Thing.
Read more of this story at Slashdot.

Read more of this story at Slashdot.